﻿/*
 ***************************************************************************
 * Microsoft Visual C# .NET
 * 名称：       Shpm.App.Input.Dao.SaleProcessDao
 * 类型：       销售流程登记画面 数据库操作层
 * 功能说明：   销售流程跟踪操作
 * 作者：       章 昕
 * 创建日期：   2007/08/30
 * 修改日期     修改者      修改内容
 * 
 * 
 * ---
 ***************************************************************************
*/
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Collections;
using Shpm.System.Db;
using Shpm.App.Commons.Db.Beans.Master;
using Shpm.App.Commons.Db.Beans.Inp;
using Shpm.App.Input.Bean;
using Shpm.App.Master.Bean;


/// <summary>
/// Summary description for SaleProcessDao
/// </summary>
namespace Shpm.App.Input.Dao
{
    public class SaleProcessDao : ShpmBaseDao
    {
        public SaleProcessDao() { }

        // 销售经理角色
        public const string ROLE_MANAGER = "ROLE_SALE_MANAGER";

        // 销售步序1-6 
        // 礼品发放
        public const int SALE_PROCESS_STEP_6 = 6;
        // 缴费
        public const int SALE_PROCESS_STEP_5 = 5;
        // 合同签订
        public const int SALE_PROCESS_STEP_4 = 4;
        // 资格审核
        public const int SALE_PROCESS_STEP_3 = 3;
        // 体检报告
        public const int SALE_PROCESS_STEP_2 = 2;
        // 入会登记
        public const int SALE_PROCESS_STEP_1 = 1;
        public const int SALE_PROCESS_STEP_0 = 0;

        // 从数据字典中取得画面列表项内容
        public const string FIND_BY_CATALOG = "CommonDictionary.FindByCatalog";

        // 销售流程 find
        public const string FINDBY_SALE_PROC = "SaleProcess.FindBySaleProcess";

        // 销售流程 insert
        public const string INSERT_SALE_PROC = "SaleProcess.InsertSaleProcess";

        // 销售流程 update
        public const string UPDATE_SALE_PROC = "SaleProcess.UpdateSaleProcess";

        // 销售流程 delete
        public const string DELETE_SALE_PROC = "SaleProcess.DeleteSaleProcess";

        // 销售流程 check 权限
        public const string CHECK_SALE_PROC_AU = "SaleProcess.CheckSaleProcessAu";

        // 销售流程-体检报告登记 check 体检报告exist
        public const string CHECK_PHYSCAL_EXIST = "SaleProcess.CheckPhyscalExist";

        // 销售流程 check 步序
        public const string CHECK_SALE_PROC_STATUS = "SaleProcess.CheckSaleProcessStatus";

        // 礼品信息列表 list
        public const string LIST_GIFT = "SaleProcess.ListGift";

        // 礼品信息列表 list
        public const string LIST_SALES_GIFT = "SaleProcess.ListSalesGift";

        // 销售流程-礼品信息 insert
        public const string INSERT_SALES_GIFT = "SaleProcess.InsertSalesGift";

        // 销售流程-礼品信息 delete
        public const string DELETE_SALES_GIFT = "SaleProcess.DeleteSalesGift";


        // 销售流程回访履历 list
        public const string LIST_SALE_PROC_VISIT = "SaleProcess.ListSaleProcessVisiting";

        //销售流程回访履历
        public const string LIST_SALE_PROC_VISIT_HISTORY = "SaleProcess.ListSaleProcessVisitingHistory";
        // 销售流程回访履历 find
        public const string FINDBY_SALE_PROC_VISIT = "SaleProcess.FindBySaleProcessVisiting";

        // 销售流程回访履历 insert
        public const string INSERT_SALE_PROC_VISIT = "SaleProcess.InsertSaleProcessVisiting";

        //销售流程回访履历
        public const string INSERT_SALE_PROCESS_VISITING_HISTORY = "SaleProcess.InsertSaleProcessVisitingHistory";

        // 销售流程回访履历 update
        public const string UPDATE_SALE_PROC_VISIT = "SaleProcess.UpdateSaleProcessVisiting";

        // 销售流程回访履历 delete
        public const string DELETE_SALE_PROC_VISIT = "SaleProcess.DeleteSaleProcessVisiting";

        // 登陆销售人员存在 check
        public const string CHECK_EMPLOYEE_EXIST = "SaleProcess.CheckEmployeeExist";        


        // 获取客户信息
        public const string GET_MEMBER_SHIP = "SaleProcess.GetMemberShip";
        // 获取客户信息
        public const string FIND_MEMBER_EDU = "SaleProcess.MemberEduList";
        public const string FIND_MEMBER_WORK = "SaleProcess.WorkList";
        public const string FIND_MEMBER_HONOR = "SaleProcess.HonorList";
        public const string FIND_INTERESTS = "SaleProcess.Interests";

        public const string INSERT_MEMBER_SHIP = "SaleProcess.BaseIn";
        public const string INSERT_MEMBER_EDU = "SaleProcess.EduIn";
        public const string INSERT_MEMBER_WORK = "SaleProcess.WorkIn";
        public const string INSERT_MEMBER_HONOR = "SaleProcess.HonorIn";
        public const string INSERT_INTERESTS = "SaleProcess.InterestIn";

        public const string UPDATE_MEMBER_SHIP = "SaleProcess.UpdPerson";
        public const string DELETE_MEMBER_SHIP = "SaleProcess.DelInfo";

        public const string DELETE_MEMBER_EDU = "SaleProcess.DelEdu";
        public const string DELETE_MEMBER_WORK = "SaleProcess.DelWork";
        public const string DELETE_MEMBER_HONOR = "SaleProcess.DelHonor";
        public const string DELETE_INTERESTS = "SaleProcess.DelInterest";

        public const string UPDATE_SALE_PROC_PERSONID = "SaleProcess.UpdateSaleProcessPersonId";

        public const string CHECK_PERSON_ID = "SaleProcess.CheckPersonId";

        /** 查询指定销售编号且意向大于指定分数的记录 */
        public const string FIND_INTENT_BY_SALE_PROCESS = "SaleProcess.FindIntentBySaleProcess";

        public const string EXISTS_INTENT_BY_SALE_PROCESS = "FindIntentBySaleProcess";

        //销售过程update(Family系列4个字段)
        public const string UPDATE_SALE_PROC_FAMILY = "SaleProcess.UpdateSaleProcessFamily";

        //根据会员号查找销售过程
        public const string GET_SALE_PROC = "SaleProcess.GetSaleProcess";






        /*
         *名称： GetSaleProcess
         *功能： 根据会员号查找销售过程。
         *参数： paramBean - 检索参数
         *返回： 数据字典列表 
         *说明： 
        */
        public SaleProcessBean GetSaleProcess(SaleProcessBean paramBean)
        {
            return (SaleProcessBean)base.QueryForObject(GET_SALE_PROC, paramBean);
        }

        /*
         *名称： FindByCatalog
         *功能： 取得数据字典列表对象。
         *参数： paramBean - 检索参数
         *返回： 数据字典列表 
         *说明： 从数据字典中取得画面列表项内容
        */
        public IList FindByCatalog(CommonDictionaryBean paramBean)
        {
            return base.QueryForList(FIND_BY_CATALOG, paramBean);
        }

        /*
       *名称： FindBySaleProcess
       *功能： 取得销售流程对象。
       *参数： paramBean - 检索参数
       *返回： 销售流程对象 
       *说明： 取得销售流程信息 get by id
      */
        public SaleProcessBean FindBySaleProcess(SaleProcessBean paramBean)
        {
            return (SaleProcessBean)base.QueryForObject(FINDBY_SALE_PROC, paramBean);
        }

        /*
         *名称： Insert
         *功能： 登录销售流程对象。
         *参数： paramBean - 登录对象
         *返回： 登录的对象
         *说明： 销售流程 insert 
        */
        public Object Insert(SaleProcessBean paramBean)
        {
            return base.Insert(INSERT_SALE_PROC, paramBean);
        }

        /*
         *名称： Update
         *功能： 更新销售流程对象。
         *参数： paramBean - 更新对象
         *返回： 更新记录数
         *说明： 销售流程 update 
        */
        public int Update(SaleProcessBean paramBean)
        {
            return base.Update(UPDATE_SALE_PROC, paramBean);
        }

        /*
         *名称： Delete
         *功能： 删除销售流程对象。
         *参数： paramBean - 删除对象
         *返回： 删除记录数
         *说明： 销售流程 delete 
        */
        public int Delete(SaleProcessBean paramBean)
        {
            return base.Delete(DELETE_SALE_PROC, paramBean);
        }

        /*
         *名称： ListSaleProcVisit
         *功能： 取得销售流程回访履历列表对象。
         *参数： paramBean - 检索参数
         *返回： 销售流程回访履历列表 
         *说明： 从销售流程回访履历中取得画面列表项内容
        */
        public IList ListSaleProcVisit(InpSalesVistingBean paramBean)
        {
            return base.QueryForList(LIST_SALE_PROC_VISIT, paramBean);
        }
        /*
         *名称： ListSaleProcVisitHistory
         *功能： 取得销售流程回访履历列表对象。
         *参数： paramBean - 检索参数
         *返回： 销售流程回访履历列表 
         *说明： 从销售流程回访履历中取得画面列表项内容
        */
        public IList ListSaleProcVisitHistory(InpSalesVistingBean paramBean)
        {
            return base.QueryForList(LIST_SALE_PROC_VISIT_HISTORY, paramBean);
        }
        
        /*
       *名称： FindBySaleProcess
       *功能： 取得销售流程回访履历对象。
       *参数： paramBean - 检索参数
       *返回： 销售流程回访履历对象 
       *说明： 取得销售流程回访履历信息 get by id
      */
        public InpSalesVistingBean FindBySaleProcessVisit(InpSalesVistingBean paramBean)
        {
            return (InpSalesVistingBean)base.QueryForObject(FINDBY_SALE_PROC_VISIT, paramBean);
        }

        /*
          *名称： Insert
          *功能： 登录销售流程回访履历对象。
          *参数： paramBean - 登录对象
          *返回： 登录的对象
          *说明： 销售流程回访履历 insert 
         */
        public Object Insert(InpSalesVistingBean paramBean)
        {
            return base.Insert(INSERT_SALE_PROC_VISIT, paramBean);
        }

        /*
          *名称： Insert
          *功能： 登录销售流程回访履历对象。
          *参数： paramBean - 登录对象
          *返回： 登录的对象
          *说明： 销售流程回访履历 insert 
         */
        public Object InsertHistory(InpSalesVistingBean paramBean)
        {
            return base.Insert(INSERT_SALE_PROCESS_VISITING_HISTORY, paramBean);
        }
        /*
         *名称： Update
         *功能： 更新销售流程回访履历对象。
         *参数： paramBean - 更新对象
         *返回： 更新记录数
         *说明： 销售流程回访履历 update 
        */
        public int Update(InpSalesVistingBean paramBean)
        {
            return base.Update(UPDATE_SALE_PROC_VISIT, paramBean);
        }

        /*
         *名称： Delete
         *功能： 删除销售流程回访履历对象。
         *参数： paramBean - 删除对象
         *返回： 删除记录数
         *说明： 销售流程回访履历 delete 
        */
        public int Delete(InpSalesVistingBean paramBean)
        {
            return base.Delete(DELETE_SALE_PROC_VISIT, paramBean);
        }

        /*
        *名称： CheckEmployeeExist
        *功能： 取得销售流程列表对象。
        *参数： paramBean - 检索参数
        *返回： 销售流程列表 
        *说明： 
       */
        public IList CheckEmployeeExist(MstEmployeeBean paramBean)
        {
            return base.QueryForList(CHECK_EMPLOYEE_EXIST, paramBean);
        }

        /*
        *名称： CheckSaleProcessAu
        *功能： 取得销售流程列表对象。
        *参数： paramBean - 检索参数
        *返回： 销售流程列表 
        *说明： 
       */
        public IList CheckSaleProcessAu(SaleProcessBean paramBean)
        {
            return base.QueryForList(CHECK_SALE_PROC_AU, paramBean);
        }

        /*
        *名称： CheckPhysicalExt
        *功能： 取得体检报告列表对象。
        *参数： paramBean - 检索参数
        *返回： 体检报告列表 
        *说明： 
       */
        public IList CheckPhysicalExt(InpPhyscalBean paramBean)
        {
            return base.QueryForList(CHECK_PHYSCAL_EXIST, paramBean);
        }

        /*
         *名称： ListGift
         *功能： 取得礼品信息列表对象。
         *参数： paramBean - 检索参数
         *返回： 礼品信息列表 
         *说明： 从礼品信息中取得画面列表项内容
        */
        public IList ListGift(MstGiftBean paramBean)
        {
            return base.QueryForList(LIST_GIFT, paramBean);
        }

        /*
         *名称： ListSalesGift
         *功能： 取得礼品信息列表对象。
         *参数： paramBean - 检索参数
         *返回： 礼品信息列表 
         *说明： 从礼品信息中取得画面列表项内容
        */
        public IList ListSalesGift(SalesGiftBean paramBean)
        {
            return base.QueryForList(LIST_SALES_GIFT, paramBean);
        }

        /*
         *名称： InsertSalesGift
         *功能： 登录销售流程--礼品信息列表对象。
         *参数： paramBean       - 更新销售流程对象       
         *　　　 paramList       - 登录对象列表
         *返回： 登录的记录数
         *说明： 销售流程--礼品信息 insert 
        */
        public int UpdProcInsSalesGift(SaleProcessBean paramBean, IList paramList)
        {
            try
            {
                int numInsert = 0;
                SalesGiftBean beanSG = null;

                // 开始事务 
                base.BeginTransaction();

                // 更新销售流程数据
                this.Update(paramBean);

                // 删除原有礼品发放数据                
                beanSG = new SalesGiftBean();
                beanSG.SaleProcId = paramBean.SaleProcId;
                this.Delete(beanSG);

                // 登记礼品发放记录
                if (paramList != null && paramList.Count > 0)
                {
                    IEnumerator itr = paramList.GetEnumerator();
                    while (itr.MoveNext())
                    {
                        beanSG = new SalesGiftBean();
                        beanSG.SaleProcId = paramBean.SaleProcId;
                        beanSG.GiftId = ((SalesGiftBean)itr.Current).GiftId;
                        beanSG.Quantity = ((SalesGiftBean)itr.Current).Quantity;
                        beanSG.UserId = ((SalesGiftBean)itr.Current).UserId;
                        this.Insert(beanSG);
                        numInsert++;
                    }
                }

                // 提交事务
                base.CommitTransaction();

                return numInsert;
            }
            catch (Exception e)
            {
                // 回滚事务
                base.RollBackTransaction();
                throw e;
            }

        }

        /*
         *名称： Insert
         *功能： 登录销售流程--礼品信息对象。
         *参数： paramBean - 登录对象
         *返回： 登录的对象
         *说明： 销售流程--礼品信息 insert 
        */
        public Object Insert(SalesGiftBean paramBean)
        {
            return base.Insert(INSERT_SALES_GIFT, paramBean);
        }

        /*
         *名称： Delete
         *功能： 删除销售流程--礼品信息对象。
         *参数： paramBean - 删除对象
         *返回： 删除记录数
         *说明： 销售流程--礼品信息 delete 
        */
        public int Delete(SalesGiftBean paramBean)
        {
            return base.Delete(DELETE_SALES_GIFT, paramBean);
        }


        /*
        *名称： CheckStatus
        *功能： 判断当前流程状态 。
        *参数： paramBean - 检索参数
        *返回： 体检报告列表 
        *说明： 判断 step 是否为当前流程的下一个状态
       */
        public Boolean CheckStatus(int saleProcId, int step)
        {
            IList list = null;
            SaleProcessBean bean = new SaleProcessBean();
            bean.SaleProcId = saleProcId;
            bean.CurrentStep = step;
            list = base.QueryForList(CHECK_SALE_PROC_STATUS, bean);
            return !(list == null || list.Count == 0);
        }


        public SaleProcessMemberShipBean GetMemberShip(SaleProcessMemberShipBean paramBean)
        {
            return (SaleProcessMemberShipBean)base.QueryForObject(GET_MEMBER_SHIP, paramBean);
        }

        public IList findEdu(EducationBean bean)
        {

            return base.QueryForList(FIND_MEMBER_EDU, bean);
        }
        public IList findWork(WorkBean bean)
        {

            return base.QueryForList(FIND_MEMBER_WORK, bean);
        }
        public IList findHonor(EncouragementBean bean)
        {

            return base.QueryForList(FIND_MEMBER_HONOR, bean);
        }


        public IList findInterests(InterestBean bean)
        {

            return base.QueryForList(FIND_INTERESTS, bean);
        }




        public object InsertBase(SaleProcessMemberShipBean bean)
        {

            return base.Insert(INSERT_MEMBER_SHIP, bean);
        }
        public object InsertEdu(EducationBean bean)
        {

            return base.Insert(INSERT_MEMBER_EDU, bean);
        }
        public object InsertWork(WorkBean bean)
        {

            return base.Insert(INSERT_MEMBER_WORK, bean);
        }
        public object InsertHonor(EncouragementBean bean)
        {

            return base.Insert(INSERT_MEMBER_HONOR, bean);
        }

        public object InsertInterest(InterestBean bean)
        {

            return base.Insert(INSERT_INTERESTS, bean);
        }



        public void InsertInfo(SaleProcessMemberShipBean bean)
        {
            try
            {
                base.BeginTransaction();
                /*基本信息*/
                int i = (int)InsertBase(bean);
                bean.PersonId = i;
                /*教育*/
                InsertEduCon(bean);

                /*工作*/
                InsertWorkCon(bean);

                /*荣誉*/
                InsertHonorCon(bean);

                InserIterestCon(bean);

                bean.CurrentStep = SALE_PROCESS_STEP_1;
                UpdSaleProcePersonId(bean);

                base.CommitTransaction();
            }
            catch (Exception e)
            {
                //log.Fatal(e);
                base.RollBackTransaction();
                throw new DataAccessException(e);
            }
        }

        public void UpdInfo(SaleProcessMemberShipBean bean)
        {
            try
            {
                base.BeginTransaction();
                /*基本信息*/
                UpdPerson(bean);

                /*教育*/
                DelEdu(bean);
                InsertEduCon(bean);

                /*工作*/
                DelWork(bean);
                InsertWorkCon(bean);

                /*荣誉*/
                DelHonor(bean);
                InsertHonorCon(bean);

                DelInterest(bean);
                InserIterestCon(bean);

                bean.CurrentStep = bean.CurrentStep;
                UpdSaleProcePersonId(bean);

                base.CommitTransaction();
            }
            catch (Exception e)
            {
                //log.Fatal(e);
                base.RollBackTransaction();
                throw new DataAccessException(e);
            }
        }

        private void InsertEduCon(SaleProcessMemberShipBean bean)
        {
            IList list = bean.EduList;
            EducationBean eduBean = null;
            if (list.Count != 0)
            {
                IEnumerator iem = list.GetEnumerator();
                while (iem.MoveNext())
                {
                    eduBean = (EducationBean)iem.Current;
                    eduBean.PersonId = bean.PersonId;
                    eduBean.UserId = bean.UserId;
                    InsertEdu(eduBean);
                }
            }
        }


        private void InsertWorkCon(SaleProcessMemberShipBean bean)
        {
            IList list = bean.WorkList;
            WorkBean workBean = null;
            if (list.Count != 0)
            {
                IEnumerator iem = list.GetEnumerator();
                while (iem.MoveNext())
                {
                    workBean = (WorkBean)iem.Current;
                    workBean.PersonId = bean.PersonId;
                    workBean.UserId = bean.UserId;
                    InsertWork(workBean);
                }
            }
        }

        private void InsertHonorCon(SaleProcessMemberShipBean bean)
        {
            IList list = bean.HonorList;
            EncouragementBean honorBean = null;
            if (list.Count != 0)
            {
                IEnumerator iem = list.GetEnumerator();
                while (iem.MoveNext())
                {
                    honorBean = (EncouragementBean)iem.Current;
                    honorBean.PersonId = bean.PersonId;
                    honorBean.UserId = bean.UserId;
                    InsertHonor(honorBean);
                }
            }
        }

        private void InserIterestCon(SaleProcessMemberShipBean bean)
        {

            IList newList = new ArrayList();
            CheckBoxList interestList = null;
            IEnumerator iem = bean.InterestsList.GetEnumerator();
            InterestBean interestBean = null;
            while (iem.MoveNext())
            {
                interestList = (CheckBoxList)iem.Current;

                foreach (ListItem item in interestList.Items)
                {
                    if (item.Selected)
                    {

                        interestBean = new InterestBean();
                        interestBean.PersonId = bean.PersonId;
                        interestBean.InterestId = item.Value;
                        interestBean.UserId = bean.UserId;
                        //newList.Add(interestBean);
                        InsertInterest(interestBean);
                    }
                }

            }
            // bean.InterestsList = newList;



        }


        public void DelEdu(SaleProcessMemberShipBean bean)
        {
            base.Delete(DELETE_MEMBER_EDU, bean);
        }
        public void DelWork(SaleProcessMemberShipBean bean)
        {
            base.Delete(DELETE_MEMBER_WORK, bean);
        }
        public void DelHonor(SaleProcessMemberShipBean bean)
        {
            base.Delete(DELETE_MEMBER_HONOR, bean);
        }
        public void DelInterest(SaleProcessMemberShipBean bean)
        {
            base.Delete(DELETE_INTERESTS, bean);
        }


        public int DelPerson(SaleProcessMemberShipBean bean)
        {
            return base.Delete(DELETE_MEMBER_SHIP, bean);
        }

        public int UpdPerson(SaleProcessMemberShipBean bean)
        {
            return base.Update(UPDATE_MEMBER_SHIP, bean);
        }


        private int UpdSaleProcePersonId(SaleProcessMemberShipBean bean)
        {
            return base.Update(UPDATE_SALE_PROC_PERSONID, bean);
        }

        public void DelSaleProcePerson(SaleProcessMemberShipBean bean)
        {
            base.BeginTransaction();
            SaleProcessMemberShipBean paramBean = new SaleProcessMemberShipBean();
            paramBean.SaleProcId = bean.SaleProcId;
            paramBean.CurrentStep = SALE_PROCESS_STEP_0;
            UpdSaleProcePersonId(paramBean);
            // DelPerson(bean);
            base.CommitTransaction();
        }


        public IList CheckPersonId(SaleProcessMemberShipBean bean)
        {
            return base.QueryForList(CHECK_PERSON_ID, bean);
        }

        public IList FindIntentBySaleProcess(SaleProcessBean paramBean)
        {
            return base.QueryForList(FIND_INTENT_BY_SALE_PROCESS, paramBean);
        }

        // 
        public SaleProcessBean InsertProcVist(SaleProcessBean paramBean)
        {
            try
            {
                // 开始事务 
                base.BeginTransaction();

                // insert SaleProcess
                Object retKey = this.Insert(paramBean);

                if (retKey != null)
                {
                    paramBean.SaleProcId = Convert.ToInt32(retKey);

                    /* commented by zhang at 2007/10/08 
                    //insert SaleVisiting
                    //InpSalesVistingBean beanV = new InpSalesVistingBean();
                    //beanV.SaleProcId = paramBean.SaleProcId;
                    //beanV.Memo = paramBean.RelationMemo;
                    //beanV.CancelFlg = false;
                    //beanV.UserId = paramBean.UserId;
                    //this.Insert(beanV);
                       commented by zhang at 2007/10/08 */
                }

                // 提交事务
                base.CommitTransaction();

            }
            catch (Exception e)
            {
                // 回滚事务
                paramBean = null;
                base.RollBackTransaction();
                throw e;
            }

            return paramBean;
        }

        public void UpdateProcVist(SaleProcessBean paramBean)
        {
            try
            {
                // 开始事务 
                base.BeginTransaction();

                // update SaleProcess
                this.Update(paramBean);

                /* commented by zhang at 2007/10/08 
                // insert SaleVisiting
                //InpSalesVistingBean beanV = new InpSalesVistingBean();
                //beanV.SaleProcId = paramBean.SaleProcId;
                //beanV.Memo = paramBean.RelationMemo;
                //beanV.CancelFlg = false;
                //beanV.UserId = paramBean.UserId;
                //this.Insert(beanV);
                   commented by zhang at 2007/10/08 */

                // 提交事务
                base.CommitTransaction();

            }
            catch (Exception e)
            {
                // 回滚事务                
                base.RollBackTransaction();
                throw e;
            }
        }

        //销售过程update(Family系列4个字段)
        public int UpdSaleProcFamily(SaleProcessBean bean)
        {
            return base.Update(UPDATE_SALE_PROC_FAMILY, bean);
        }
    }
}
